Graphics rendering and other visualization applications typically utilize accelerated hardware, firmware, and sometimes even software modules to perform compute-intensive rendering operations. These applications also utilize a graphics system interface such as OPENGL® or DIRECT3D® to control low-level graphics drawing operations in these accelerated modules. For example, OPENGL® utilizes a variety of low-level models such as textures which may be defined for objects within scenes, and lighting models, which may define light sources and the manner in which surfaces in the scenes reflect light therefrom. Controlling the appearance of these objects typically requires the use of complex effects such as blending, shading and texturing, and may be performed using visualization applications such as programmable or procedural shading applications. Usually, each of these operations may require significant computing time and/or resources. In many applications, including interactive applications, it may be desirable to minimize one or both of these requirements.
Most processing within a graphics pipeline is performed on all of the image pixel data that is passed thereto. A graphics system interface such as OPENGL® may be used to select various pixels and to control processing of pixel-based appearances by using multiple passes through the graphics pipeline. Unfortunately, many conventional graphics systems typically require multiple fetch operations in the graphics pipeline to be performed to retrieve both geometry data and texture data to arrive at a final appearances. Moreover, many systems also typically require a masking operation to mask or cull relevant pixels to be blended with other images in a next pass through the graphics pipeline. For example, a bounding box of geometry encompassing the stored image pixels from a prior pass is typically used by these systems to retrieve and to register the image pixels with a result in a frame buffer that has been computed in the next pass so that they may be blended in a third pass. The unnecessary pixels between the bounding box and relevant stored pixels are then culled or masked out before the blending operation. Each of these fetch and/or mask operations undesirably increases the processing time with each of these passes. These conventional systems may also reduce the flexibility with which programmable per-pixel applications may be parameterized, in addition to reducing processing speeds.
Moreover, effects such as texture and lighting are typically computed using vertices provided by the geometry data, rather than per pixel. Because each value between the vertices must then be interpolated, the final appearance is usually undesirably uneven. Some systems have implemented methods in software, or software embedded in hardware, to perform per pixel computations to even out these lighting effects. However, these systems typically suffer from slow processing time.